home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / clang / rst2_src.zip / RST2.C < prev    next >
C/C++ Source or Header  |  1995-01-02  |  12KB  |  444 lines
  1.  
  2.  
  3.  //**********************************************
  4.  // RST 2 Small Intro
  5.  // By Synthetic Man
  6.  // Of The Rising Sun Team
  7.  // In December 1994
  8.  //**********************************************
  9.  // To Contact Us Write To:
  10.  // S-Mail:
  11.  // Rising Sun Team
  12.  // Via Ronchi Bassi, 13
  13.  // 35135 Padova (Italy)
  14.  // E-Mail:
  15.  // sakurambo@paola.dei.unipd.it
  16.  // barchio@paola.dei.unipd.it
  17.  // silviazm@paola.dei.unipd.it
  18.  //**********************************************
  19.  // Use COMPACT Model For Code Generation
  20.  // Use A Project RST2 With MODEX.OBJ And RST2.C
  21.  //**********************************************
  22.  // This source code is totally free and you can
  23.  // use it for your demos/intros but don't forget
  24.  // to greet us of RST
  25.  //**********************************************
  26.  
  27.  
  28.  //--------------------------------------------------
  29.  // librerie standard
  30.  //--------------------------------------------------
  31.  #include <stdlib.h>
  32.  #include <stdio.h>
  33.  #include <string.h>
  34.  #include <conio.h>
  35.  
  36.  //--------------------------------------------------
  37.  // librerie mode x
  38.  //--------------------------------------------------
  39.  #include "modex.h"
  40.  
  41.  //--------------------------------------------------
  42.  // includo dei dati
  43.  //--------------------------------------------------
  44.  #include "ball.c"    //immagine palla
  45.  #include "pattern.c" //immagine pattern
  46.  #include "palette.c" //palette palla
  47.  
  48.  //--------------------------------------------------
  49.  // definizione dati
  50.  //--------------------------------------------------
  51.  #define colore_minimo   97
  52.  #define colore_massimo  107
  53.  #define x 55
  54.  #define y 10
  55.  #define distanza_x 14
  56.  #define distanza_y 12
  57.  #define vga_x 360
  58.  #define vga_y 240
  59.  
  60.  //--------------------------------------------------
  61.  // variabili globali
  62.  //--------------------------------------------------
  63.  unsigned char far *sprite_palla;
  64.  unsigned char far *sprite_pattern;
  65.  unsigned char r[256],g[256],b[256];
  66.  unsigned char r_old,g_old,b_old;
  67.  
  68.  //--------------------------------------------------
  69.  // testo scritte
  70.  //--------------------------------------------------
  71.  char testo[][80]={"---== The Rising Sun Team ==---",
  72.            "",
  73.            "Present This Simple Intro Dedicated To All",
  74.            "Italian Guys Who Want Enjoy PC Coding!",
  75.            "If You Are In Trouble Contact Us Now!",
  76.            "",
  77.            "Intro Code & Graphic By Synthetic Man",
  78.            "",
  79.            "The Members Of Rising Sun Team Are:",
  80.            "Synthetic Man, Crazy Byte, Cyber Punk Boy,",
  81.            "Manga Man, Mr Babiox, Crazy Teo, Pit."};
  82.  
  83.  char testo_fine[][80]={" ╔══════════════════════════════╗",
  84.             " ║ The Rising Sun Team          ║",
  85.             " ║ RST2 Intro                   ║",
  86.             " ╠══════════════════════════════╣",
  87.             " ║ Idea, Code & Graphic         ║",
  88.             " ║ By Synthetic Man             ║",
  89.             " ╠══════════════════════════════╣",
  90.             " ║ S-Mail:                      ║",
  91.             " ║ Rising Sun Team              ║",
  92.             " ║ Via Ronchi Bassi 13          ║",
  93.             " ║ 35135 Padova (Italy)         ║",
  94.             " ║ E-Mail:                      ║",
  95.             " ║ sakurambo@paola.dei.unipd.it ║",
  96.             " ║ barchio@paola.dei.unipd.it   ║",
  97.             " ║ silviazm@paola.dei.unipd.it  ║",
  98.             " ║ lythyum@maya.dei.unipd.it    ║",
  99.             " ╚══════════════════════════════╝",
  100.             ""};
  101.  
  102.  
  103.  //--------------------------------------------------
  104.  // posizione delle palle della scritta
  105.  //--------------------------------------------------
  106.  char posizione[]={0,0,
  107.            0,1,
  108.            0,2,
  109.            0,3,
  110.            0,4,
  111.            0,5,
  112.            0,6,
  113.            0,7,
  114.            1,0,
  115.            1,4,
  116.            2,0,
  117.            2,4,
  118.            2,5,
  119.            3,0,
  120.            3,4,
  121.            3,6,
  122.            4,0,
  123.            4,1,
  124.            4,2,
  125.            4,3,
  126.            4,4,
  127.            4,7,
  128.            6,0,
  129.            6,1,
  130.            6,2,
  131.            6,3,
  132.            6,4,
  133.            6,7,
  134.            7,0,
  135.            7,4,
  136.            7,7,
  137.            8,0,
  138.            8,4,
  139.            8,7,
  140.            9,0,
  141.            9,4,
  142.            9,7,
  143.            10,0,
  144.            10,4,
  145.            10,5,
  146.            10,6,
  147.            10,7,
  148.            12,0,
  149.            13,0,
  150.            14,0,
  151.            14,1,
  152.            14,2,
  153.            14,3,
  154.            14,4,
  155.            14,5,
  156.            14,6,
  157.            14,7,
  158.            15,0,
  159.            16,0};
  160.  
  161.  //--------------------------------------------------
  162.  // ritorna il valori di rgb di un colore della pal.
  163.  //--------------------------------------------------
  164.  void get_palette(unsigned char col)
  165.  {
  166.   unsigned char  rr,gg,bb;
  167.  
  168.    asm{
  169.       mov    dx,3c7h
  170.       mov    al,col
  171.       out    dx,al
  172.  
  173.       add    dx,2
  174.  
  175.       in     al,dx
  176.       mov    [rr],al
  177.       in     al,dx
  178.       mov    [gg],al
  179.       in     al,dx
  180.       mov    [bb],al
  181.       }
  182.  
  183.    r[col]=rr;
  184.    g[col]=gg;
  185.    b[col]=bb;
  186.  }
  187.  
  188.  
  189.  //--------------------------------------------------
  190.  // vertical retrace
  191.  //--------------------------------------------------
  192.  void wait_retrace(void)
  193.   {
  194.     asm mov dx,3DAh
  195.    l1:
  196.     asm in al,dx
  197.     asm and al,08h
  198.     asm jnz l1
  199.    l2:
  200.     asm in al,dx
  201.     asm and al,08h
  202.     asm jz  l2
  203.   }
  204.  
  205.   //----------------------------------------------------
  206.   // fade off 256 colori
  207.   //----------------------------------------------------
  208.   void fade_off(unsigned char red[256],unsigned char green[256],
  209.         unsigned char blue[256])
  210.   {
  211.    int i,n;
  212.  
  213.     for(i=0;i<=64;i++)   //64=max numero di sfumature di un colore
  214.     {
  215.       for(n=0;n<=255;n++)
  216.       {
  217.       if(red[n]>0) red[n]--;
  218.       if(green[n]>0) green[n]--;
  219.       if(blue[n]>0) blue[n]--;
  220.       set_dac_register(n,red[n],green[n],blue[n]);
  221.      }
  222.     wait_retrace();
  223.     wait_retrace();
  224.    }
  225.   }
  226.  
  227.   //-----------------------------------------------
  228.   // fade in 256 colori
  229.   //-----------------------------------------------
  230.   void fade_in(unsigned char red[256],unsigned char green[256],
  231.            unsigned char blue[256])
  232.   {
  233.    int i,n,_red[256],_green[256],_blue[256];
  234.  
  235.    for(n=0;n<=255;n++)
  236.    {
  237.     _red[n]=red[n];
  238.     _green[n]=green[n];
  239.     _blue[n]=blue[n];
  240.    }
  241.  
  242.   for(n=0;n<=255;n++)
  243.    {
  244.     red[n]=0;
  245.     green[n]=0;
  246.     blue[n]=0;
  247.    }
  248.  
  249.     for(i=0;i<=64;i++)
  250.     {
  251.       for(n=0;n<=255;n++)
  252.       {
  253.       if(red[n]<_red[n]) red[n]++;
  254.       if(green[n]<_green[n]) green[n]++;
  255.       if(blue[n]<_blue[n]) blue[n]++;
  256.       set_dac_register(n,red[n],green[n],blue[n]);
  257.      }
  258.     wait_retrace();
  259.     wait_retrace();
  260.    }
  261.   }
  262.  
  263.  //--------------------------------------------------
  264.  // azzera il contenuto della palette
  265.  //--------------------------------------------------
  266.  void azzera_palette(void)
  267.  {
  268.   int n;
  269.   for(n=0;n<=255;n++)
  270.      set_dac_register(n,0,0,0);
  271.  }
  272.  
  273.  
  274.  //--------------------------------------------------
  275.  // genera il movimento dello sfondo
  276.  //--------------------------------------------------
  277.  void play_palette(void)
  278.  {
  279.   register int n,m;
  280.  
  281.  
  282.    // memorizza il primo colore della palette
  283.     r_old=r[colore_minimo];
  284.     g_old=g[colore_minimo];
  285.     b_old=b[colore_minimo];
  286.  
  287.     for(n=colore_minimo;n<=colore_massimo;n++)
  288.      {
  289.       r[n]=r[n+1];
  290.       g[n]=g[n+1];
  291.       b[n]=b[n+1];
  292.      }
  293.  
  294.     r[colore_massimo]=r_old;
  295.     g[colore_massimo]=g_old;
  296.     b[colore_massimo]=b_old;
  297.  
  298.     for(n=colore_minimo;n<=colore_massimo;n++)
  299.     set_dac_register(n,r[n],g[n],b[n]);
  300.  
  301.     wait_retrace();
  302.     wait_retrace();
  303.     wait_retrace();
  304.     wait_retrace();
  305.  
  306.   }
  307.  
  308.  
  309.  void main()
  310.  {
  311.   register int n,m;
  312.  
  313.   //--------------------------------------------------
  314.   // rileva la palette attuale
  315.   //--------------------------------------------------
  316.   for(n=0;n<=256;n++)
  317.    get_palette(n);
  318.  
  319.   //--------------------------------------------------
  320.   // fade off della schermata in modo testo
  321.   //--------------------------------------------------
  322.   fade_off(r,g,b);
  323.  
  324.   //--------------------------------------------------
  325.   // alloca i puntatori degli sprite
  326.   //--------------------------------------------------
  327.   sprite_palla=calloc(625,sizeof(unsigned char far));
  328.   sprite_pattern=calloc(400,sizeof(unsigned char far));
  329.  
  330.   //--------------------------------------------------
  331.   // costruisce lo sprite della palla
  332.   //--------------------------------------------------
  333.   for(n=0;n<625;n++)
  334.     sprite_palla[n]=palla[n];
  335.  
  336.   //--------------------------------------------------
  337.   // costruisce lo sprite del pattern
  338.   //--------------------------------------------------
  339.   for(n=0;n<400;n++)
  340.     sprite_pattern[n]=pattern[n];
  341.  
  342.   //--------------------------------------------------
  343.   // inizializza il mode x in 360x240
  344.   //--------------------------------------------------
  345.   set_modex(6);
  346.  
  347.   //--------------------------------------------------
  348.   // copia la palette in tre vettori r,g,b
  349.   //--------------------------------------------------
  350.   m=0;
  351.   for(n=0;n<256;n++)
  352.    {
  353.     r[n]=palette[m];
  354.     g[n]=palette[m+1];
  355.     b[n]=palette[m+2];
  356.     m+=3;
  357.    }
  358.  
  359.   //--------------------------------------------------
  360.   // azzera la palette per nascondere l'immagine
  361.   //--------------------------------------------------
  362.   azzera_palette();
  363.  
  364.   //--------------------------------------------------
  365.   // disegna lo sfondo
  366.   //--------------------------------------------------
  367.   for(n=0;n<=(vga_y/20)-1;n++)
  368.    for(m=0;m<=(vga_x/20)-1;m++)
  369.     draw_bitmap(sprite_pattern,m*20,n*20,20,20);
  370.  
  371.   //--------------------------------------------------
  372.   // disegna la scritta
  373.   //--------------------------------------------------
  374.   for(n=0;n<=106;n+=2)
  375.    tdraw_bitmap(sprite_palla,x+(posizione[n]*distanza_x),
  376.         y+(posizione[n+1]*distanza_y),25,25);
  377.  
  378.   //--------------------------------------------------
  379.   // prepara una scalatura dei colori dello sfondo
  380.   //--------------------------------------------------
  381.   for(n=colore_massimo,m=colore_minimo;n>=colore_minimo;n--,m++)
  382.    {
  383.     r[n]=r[m];
  384.     g[n]=g[m];
  385.     b[n]=b[m];
  386.    }
  387.  
  388.   //--------------------------------------------------
  389.   // scrive il testo
  390.   //--------------------------------------------------
  391.   for(n=0;n<=10;n++)
  392.    tprint_str(testo[n],strlen(testo[n]),(vga_x/2)-((strlen(testo[n])*8)/2),
  393.           n*10+130,1);
  394.  
  395.   //--------------------------------------------------
  396.   // fade in dell'immagine dell'intro
  397.   //--------------------------------------------------
  398.   fade_in(r,g,b);
  399.  
  400.   //--------------------------------------------------
  401.   // ciclo principale
  402.   //--------------------------------------------------
  403.   for(;;)
  404.   {
  405.    if (kbhit())
  406.     if (getch()==27)   //controlla se viene premuto esc
  407.      break;
  408.  
  409.    play_palette();
  410.   }
  411.  
  412.   //--------------------------------------------------
  413.   // fade off dell'immagine dell'intro
  414.   //--------------------------------------------------
  415.   fade_off(r,g,b);
  416.  
  417.   //--------------------------------------------------
  418.   // ritorna in modo tsto a 80 colonne
  419.   //--------------------------------------------------
  420.   textmode(3);
  421.  
  422.   //--------------------------------------------------
  423.   // rileva la palette attuale
  424.   //--------------------------------------------------
  425.   for(n=0;n<=256;n++)
  426.    get_palette(n);
  427.  
  428.   //--------------------------------------------------
  429.   // azzera la palette
  430.   //--------------------------------------------------
  431.   azzera_palette();
  432.  
  433.   //--------------------------------------------------
  434.   // scrive il testo
  435.   //--------------------------------------------------
  436.   for(n=0;n<=17;n++)
  437.    printf("\n%s",testo_fine[n]);
  438.  
  439.   //--------------------------------------------------
  440.   // fade in del testo in modo testo
  441.   //--------------------------------------------------
  442.   fade_in(r,g,b);
  443.  
  444.  }